home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / gfx / 3d / irit50src.lha / irit5 / trim_lib / trim_gen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-10  |  26.0 KB  |  550 lines
  1. /******************************************************************************
  2. * Trim_aux.c - auxiliary routine to interface to different free from types.   *
  3. *******************************************************************************
  4. * Written by Gershon Elber, July. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #include "trim_loc.h"
  8.  
  9. #define VEC_FIELD_TRIES    10
  10. #define VEC_FIELD_START_STEP 1e-6
  11.  
  12. /*****************************************************************************
  13. * DESCRIPTION:                                                               M
  14. * Allocates a trimming curve segment structure.                              M
  15. *                                                                            *
  16. * PARAMETERS:                                                                M
  17. *   UVCrv:     A UV curve. Must be an E2 curve.                              M
  18. *   EucCrv:    Optional Euclidean curve. Must be an E3 curve.                M
  19. *                                                                            *
  20. * RETURN VALUE:                                                              M
  21. *   TrimCrvSegStruct *:   A trimming curve segment structure.                M
  22. *                                                                            *
  23. * KEYWORDS:                                                                  M
  24. *   TrimCrvSegNew, allocation                                                M
  25. *****************************************************************************/
  26. TrimCrvSegStruct *TrimCrvSegNew(CagdCrvStruct *UVCrv, CagdCrvStruct *EucCrv)
  27. {
  28.     TrimCrvSegStruct
  29.     *TrimCrvSeg = (TrimCrvSegStruct *)
  30.         IritMalloc(sizeof(TrimCrvSegStruct));
  31.  
  32.     if ((TrimCrvSeg -> UVCrv = UVCrv) != NULL)
  33.     TrimCrvSeg -> UVCrv -> Pnext = NULL;
  34.     if ((TrimCrvSeg -> EucCrv = EucCrv) != NULL)
  35.     TrimCrvSeg -> EucCrv -> Pnext = NULL;
  36.     TrimCrvSeg -> Pnext = NULL;
  37.     TrimCrvSeg -> Attr = NULL;
  38.  
  39.     return TrimCrvSeg;
  40. }
  41.  
  42. /*****************************************************************************
  43. * DESCRIPTION:                                                               M
  44. * Duplicates a trimming curve segment structure.                             M
  45. *                                                                            *
  46. * PARAMETERS:                                                                M
  47. *   TrimCrvSeg: A trimming curve segment to duplicate.                 M
  48. *                                                                            *
  49. * RETURN VALUE:                                                              M
  50. *   TrimCrvSegStruct *:   A trimming curve segment structure.                M
  51. *                                                                            *
  52. * KEYWORDS:                                                                  M
  53. *   TrimCrvSegNew, allocation                                                M
  54. *****************************************************************************/
  55. TrimCrvSegStruct *TrimCrvSegCopy(TrimCrvSegStruct *TrimCrvSeg)
  56. {
  57.     TrimCrvSegStruct
  58.     *NewTrimCrvSeg = (TrimCrvSegStruct *)
  59.         IritMalloc(sizeof(TrimCrvSegStruct));
  60.  
  61.     NewTrimCrvSeg -> UVCrv = CagdCrvCopy(TrimCrvSeg -> UVCrv);
  62.     if (TrimCrvSeg -> EucCrv)
  63.     NewTrimCrvSeg -> EucCrv = CagdCrvCopy(TrimCrvSeg -> EucCrv);
  64.     else
  65.     NewTrimCrvSeg -> EucCrv = NULL;
  66.     NewTrimCrvSeg -> Pnext = NULL;
  67.     NewTrimCrvSeg -> Attr = NULL;
  68.  
  69.     return NewTrimCrvSeg;
  70. }
  71.  
  72. /*****************************************************************************
  73. * DESCRIPTION:                                                               M
  74. * Allocates and copies a list of trimming curve segment structures.         M
  75. *                                                                            *
  76. * PARAMETERS:                                                                M
  77. *   TrimCrvSegList:   To be copied.                                          M
  78. *                                                                            *
  79. * RETURN VALUE:                                                              M
  80. *   TrimCrvSegStruct *:  A duplicated list of trimming curve segments.       M
  81. *                                                                            *
  82. * KEYWORDS:                                                                  M
  83. *   TrimCrvSegCopyList, copy                                                 M
  84. *****************************************************************************/
  85. TrimCrvSegStruct *TrimCrvSegCopyList(TrimCrvSegStruct *TrimCrvSegList)
  86. {
  87.     TrimCrvSegStruct *TrimCrvSegTemp, *NewTrimCrvSegList;
  88.  
  89.     if (TrimCrvSegList == NULL)
  90.     return NULL;
  91.     TrimCrvSegTemp = NewTrimCrvSegList = TrimCrvSegCopy(TrimCrvSegList);
  92.     TrimCrvSegList = TrimCrvSegList -> Pnext;
  93.     while (TrimCrvSegList) {
  94.     TrimCrvSegTemp -> Pnext = TrimCrvSegCopy(TrimCrvSegList);
  95.     TrimCrvSegTemp = TrimCrvSegTemp -> Pnext;
  96.     TrimCrvSegList = TrimCrvSegList -> Pnext;
  97.     }
  98.     return NewTrimCrvSegList;
  99. }
  100.  
  101. /*****************************************************************************
  102. * DESCRIPTION:                                                               M
  103. * Deallocates a trimming curve segment structure.                            M
  104. *                                                                            *
  105. * PARAMETERS:                                                                M
  106. *   TrimCrvSeg: A trimming curve segment to free.                            M
  107. *                                                                            *
  108. * RETURN VALUE:                                                              M
  109. *   void                                                                     M
  110. *                                                                            *
  111. * KEYWORDS:                                                                  M
  112. *   TrimCrvSegFree, allocation                                               M
  113. *****************************************************************************/
  114. void TrimCrvSegFree(TrimCrvSegStruct *TrimCrvSeg)
  115. {
  116.     CagdCrvFree(TrimCrvSeg -> UVCrv);
  117.     CagdCrvFree(TrimCrvSeg -> EucCrv);
  118.     AttrFreeAttributes(&TrimCrvSeg -> Attr);
  119.     IritFree((VoidPtr) TrimCrvSeg);
  120. }
  121.  
  122. /*****************************************************************************
  123. * DESCRIPTION:                                                               M
  124. * Deallocates a list of trimming curve segment structures.                   M
  125. *                                                                            *
  126. * PARAMETERS:                                                                M
  127. *   TrimCrvSegList: A list of trimming curve segments to free.               M
  128. *                                                                            *
  129. * RETURN VALUE:                                                              M
  130. *   void                                                                     M
  131. *                                                                            *
  132. * KEYWORDS:                                                                  M
  133. *   TrimCrvSegFreeList, allocation                                           M
  134. *****************************************************************************/
  135. void TrimCrvSegFreeList(TrimCrvSegStruct *TrimCrvSegList)
  136. {
  137.     TrimCrvSegStruct *TrimCrvTemp;
  138.  
  139.     while (TrimCrvSegList) {
  140.     TrimCrvTemp = TrimCrvSegList -> Pnext;
  141.     TrimCrvSegFree(TrimCrvSegList);
  142.     TrimCrvSegList = TrimCrvTemp;
  143.     }
  144. }
  145.  
  146. /*****************************************************************************
  147. * DESCRIPTION:                                                               M
  148. * Allocates a trimming curve structure.                                      M
  149. *                                                                            *
  150. * PARAMETERS:                                                                M
  151. *   TrimCrvSegList:    List of trimming curve segments forming the trimming  M
  152. *                      curve.                             M
  153. *                                                                            *
  154. * RETURN VALUE:                                                              M
  155. *   TrimCrvStruct *:   A trimmig curve.                                      M
  156. *                                                                            *
  157. * KEYWORDS:                                                                  M
  158. *   TrimCrvNew, allocation                                                   M
  159. *****************************************************************************/
  160. TrimCrvStruct *TrimCrvNew(TrimCrvSegStruct *TrimCrvSegList)
  161. {
  162.    TrimCrvStruct
  163.     *TrimCrv = (TrimCrvStruct *)
  164.         IritMalloc(sizeof(TrimCrvStruct));
  165.  
  166.     TrimCrv -> TrimCrvSegList = TrimCrvSegList;
  167.     TrimCrv -> Pnext = NULL;
  168.     TrimCrv -> Attr = NULL;
  169.  
  170.     return TrimCrv;
  171. }
  172.  
  173. /*****************************************************************************
  174. * DESCRIPTION:                                                               M
  175. * Duplicates a trimming curve structure.                                 M
  176. *                                                                            *
  177. * PARAMETERS:                                                                M
  178. *   TrimCrv:   A trimming curve to duplicate.                     M
  179. *                                                                            *
  180. * RETURN VALUE:                                                              M
  181. *   TrimCrvStruct *:   A trimming curve structure.                     M
  182. *                                                                            *
  183. * KEYWORDS:                                                                  M
  184. *   TrimCrvNew, allocation                                                   M
  185. *****************************************************************************/
  186. TrimCrvStruct *TrimCrvCopy(TrimCrvStruct *TrimCrv)
  187. {
  188.     TrimCrvStruct
  189.     *NewTrimCrv = (TrimCrvStruct *)
  190.         IritMalloc(sizeof(TrimCrvStruct));
  191.  
  192.     NewTrimCrv -> TrimCrvSegList =
  193.     TrimCrvSegCopyList(TrimCrv -> TrimCrvSegList);
  194.     NewTrimCrv -> Pnext = NULL;
  195.     NewTrimCrv -> Attr = NULL;
  196.  
  197.     return NewTrimCrv;
  198. }
  199.  
  200. /*****************************************************************************
  201. * DESCRIPTION:                                                               M
  202. * Allocates and copies a list of trimming curve structures.             M
  203. *                                                                            *
  204. * PARAMETERS:                                                                M
  205. *   TrimCrvList:   To be copied.                                         M
  206. *                                                                            *
  207. * RETURN VALUE:                                                              M
  208. *   TrimCrvStruct *:  A duplicated list of trimming curves.             M
  209. *                                                                            *
  210. * KEYWORDS:                                                                  M
  211. *   TrimCrvCopyList, copy                                                    M
  212. *****************************************************************************/
  213. TrimCrvStruct *TrimCrvCopyList(TrimCrvStruct *TrimCrvList)
  214. {
  215.     TrimCrvStruct *TrimCrvTemp, *NewTrimCrvList;
  216.  
  217.     if (TrimCrvList == NULL)
  218.     return NULL;
  219.     TrimCrvTemp = NewTrimCrvList = TrimCrvCopy(TrimCrvList);
  220.     TrimCrvList = TrimCrvList -> Pnext;
  221.     while (TrimCrvList) {
  222.     TrimCrvTemp -> Pnext = TrimCrvCopy(TrimCrvList);
  223.     TrimCrvTemp = TrimCrvTemp -> Pnext;
  224.     TrimCrvList = TrimCrvList -> Pnext;
  225.     }
  226.     return NewTrimCrvList;
  227. }
  228.  
  229. /*****************************************************************************
  230. * DESCRIPTION:                                                               M
  231. * Deallocates a trimming curve structure.                                    M
  232. *                                                                            *
  233. * PARAMETERS:                                                                M
  234. *   TrimCrv: A trimming curve to free.                                      M
  235. *                                                                            *
  236. * RETURN VALUE:                                                              M
  237. *   void                                                                     M
  238. *                                                                            *
  239. * KEYWORDS:                                                                  M
  240. *   TrimCrvFree, allocation                                                  M
  241. *****************************************************************************/
  242. void TrimCrvFree(TrimCrvStruct *TrimCrv)
  243. {
  244.     TrimCrvSegFreeList(TrimCrv -> TrimCrvSegList);
  245.     AttrFreeAttributes(&TrimCrv -> Attr);
  246.     IritFree((VoidPtr) TrimCrv);
  247. }
  248.  
  249. /*****************************************************************************
  250. * DESCRIPTION:                                                               M
  251. * Deallocates a list of trimming curve structures.                         M
  252. *                                                                            *
  253. * PARAMETERS:                                                                M
  254. *   TrimCrvList: A list of trimming curve to free.                     M
  255. *                                                                            *
  256. * RETURN VALUE:                                                              M
  257. *   void                                                                     M
  258. *                                                                            *
  259. * KEYWORDS:                                                                  M
  260. *   TrimCrvFreeList, allocation                                              M
  261. *****************************************************************************/
  262. void TrimCrvFreeList(TrimCrvStruct *TrimCrvList)
  263. {
  264.     TrimCrvStruct *TrimCrvTemp;
  265.  
  266.     while (TrimCrvList) {
  267.     TrimCrvTemp = TrimCrvList -> Pnext;
  268.     TrimCrvFree(TrimCrvList);
  269.     TrimCrvList = TrimCrvTemp;
  270.     }
  271. }
  272.  
  273. /*****************************************************************************
  274. * DESCRIPTION:                                                               M
  275. *   Constructor for a trimmed surface.                         M
  276. *                                                                            *
  277. * PARAMETERS:                                                                M
  278. *   Srf:             Surface to make into a trimmed surface.                 M
  279. *   TrimCrvList:     A list of trimming curves.                     M
  280. *   HasTopLvlTrim:   Do we have a top level outer most trimming curve?         M
  281. *                                                                            *
  282. * RETURN VALUE:                                                              M
  283. *   TrimSrfStruct *: The trimmed surface.                                    M
  284. *                                                                            *
  285. * KEYWORDS:                                                                  M
  286. *   TrimSrfDomain, allocation,                                               M
  287. *****************************************************************************/
  288. TrimSrfStruct *TrimSrfNew(CagdSrfStruct *Srf,
  289.               TrimCrvStruct *TrimCrvList,
  290.               CagdBType HasTopLvlTrim)
  291. {
  292.     CagdRType UMin, UMax, VMin, VMax;
  293.     TrimSrfStruct
  294.     *TrimSrf = (TrimSrfStruct *) IritMalloc(sizeof(TrimSrfStruct));
  295.  
  296.     CagdSrfDomain(Srf, &UMin, &UMax, &VMin, &VMax);
  297.  
  298.     TrimSrf -> Srf = Srf;
  299.     TrimSrf -> Pnext = NULL;
  300.     TrimSrf -> Attr = NULL;
  301.     
  302.     if (!HasTopLvlTrim) {
  303.     CagdRType **Points;
  304.     TrimCrvStruct *TrimCrv;
  305.     CagdCrvStruct
  306.         *Crv = BspCrvNew(5, 2, CAGD_PT_E2_TYPE);
  307.  
  308.     BspKnotUniformOpen(5, 2, Crv -> KnotVector);
  309.     Points = Crv -> Points;
  310.  
  311.     Points[1][0] = UMin;
  312.     Points[2][0] = VMin;
  313.     Points[1][1] = UMax;
  314.     Points[2][1] = VMin;
  315.     Points[1][2] = UMax;
  316.     Points[2][2] = VMax;
  317.     Points[1][3] = UMin;
  318.     Points[2][3] = VMax;
  319.     Points[1][4] = UMin;
  320.     Points[2][4] = VMin;
  321.  
  322.     TrimCrv = TrimCrvNew(TrimCrvSegNew(Crv, NULL));
  323.  
  324.     TrimCrv -> Pnext = TrimCrvList;
  325.     TrimSrf -> TrimCrvList = TrimCrv;
  326.     }
  327.     else
  328.     TrimSrf -> TrimCrvList = TrimCrvList;
  329.  
  330.     return TrimSrf;
  331. }
  332.  
  333. /*****************************************************************************
  334. * DESCRIPTION:                                                               M
  335. *   Constructor for a trimmed surface.                         M
  336. *                                                                            *
  337. * PARAMETERS:                                                                M
  338. *   Srf:             Surface to make into a trimmed surface.                 M
  339. *   CagdCrvStruct:   A list of trimming curves, as regular curves.         M
  340. *   HasTopLvlTrim:   Do we have a top level outer most trimming curve?         M
  341. *                                                                            *
  342. * RETURN VALUE:                                                              M
  343. *   TrimSrfStruct *: The trimmed surface.                                    M
  344. *                                                                            *
  345. * KEYWORDS:                                                                  M
  346. *   TrimSrfDomain, allocation,                                               M
  347. *****************************************************************************/
  348. TrimSrfStruct *TrimSrfNew2(CagdSrfStruct *Srf,
  349.                CagdCrvStruct *TrimCrvList,
  350.                CagdBType HasTopLvlTrim)
  351. {
  352.     TrimCrvStruct
  353.     *TrimCrvList2 = NULL;
  354.  
  355.     while (TrimCrvList) {
  356.     CagdCrvStruct
  357.         *TrimCrvNext = TrimCrvList -> Pnext;
  358.     TrimCrvStruct
  359.         *TrimCrv = TrimCrvNew(TrimCrvSegNew(TrimCrvList, NULL));
  360.  
  361.     TrimCrvList = TrimCrvNext;
  362.  
  363.     LIST_PUSH(TrimCrv, TrimCrvList2);
  364.     }
  365.  
  366.     return TrimSrfNew(Srf, TrimCrvList2, HasTopLvlTrim);
  367. }
  368.  
  369. /*****************************************************************************
  370. * DESCRIPTION:                                                               M
  371. * Duplicates a trimming surface structure.                                 M
  372. *                                                                            *
  373. * PARAMETERS:                                                                M
  374. *   TrimSrf:   A trimming surface to duplicate.                     M
  375. *                                                                            *
  376. * RETURN VALUE:                                                              M
  377. *   TrimSrfStruct *:   A trimming surface structure.                     M
  378. *                                                                            *
  379. * KEYWORDS:                                                                  M
  380. *   TrimSrfNew, allocation                                                   M
  381. *****************************************************************************/
  382. TrimSrfStruct *TrimSrfCopy(TrimSrfStruct *TrimSrf)
  383. {
  384.     TrimSrfStruct
  385.     *NewTrimSrf = (TrimSrfStruct *)
  386.         IritMalloc(sizeof(TrimSrfStruct));
  387.  
  388.     NewTrimSrf -> TrimCrvList =
  389.     TrimCrvCopyList(TrimSrf -> TrimCrvList);
  390.     NewTrimSrf -> Srf = CagdSrfCopy(TrimSrf -> Srf);
  391.     NewTrimSrf -> Pnext = NULL;
  392.     NewTrimSrf -> Attr = NULL;
  393.  
  394.     return NewTrimSrf;
  395. }
  396.  
  397. /*****************************************************************************
  398. * DESCRIPTION:                                                               M
  399. * Allocates and copies a list of trimming surface structures.             M
  400. *                                                                            *
  401. * PARAMETERS:                                                                M
  402. *   TrimSrfList:   To be copied.                                         M
  403. *                                                                            *
  404. * RETURN VALUE:                                                              M
  405. *   TrimSrfStruct *:  A duplicated list of trimming surfaces.             M
  406. *                                                                            *
  407. * KEYWORDS:                                                                  M
  408. *   TrimSrfCopyList, copy                                                    M
  409. *****************************************************************************/
  410. TrimSrfStruct *TrimSrfCopyList(TrimSrfStruct *TrimSrfList)
  411. {
  412.     TrimSrfStruct *TrimSrfTemp, *NewTrimSrfList;
  413.  
  414.     if (TrimSrfList == NULL)
  415.     return NULL;
  416.     TrimSrfTemp = NewTrimSrfList = TrimSrfCopy(TrimSrfList);
  417.     TrimSrfList = TrimSrfList -> Pnext;
  418.     while (TrimSrfList) {
  419.     TrimSrfTemp -> Pnext = TrimSrfCopy(TrimSrfList);
  420.     TrimSrfTemp = TrimSrfTemp -> Pnext;
  421.     TrimSrfList = TrimSrfList -> Pnext;
  422.     }
  423.     return NewTrimSrfList;
  424. }
  425.  
  426. /*****************************************************************************
  427. * DESCRIPTION:                                                               M
  428. * Deallocates a trimmed surface structure.                                    M
  429. *                                                                            *
  430. * PARAMETERS:                                                                M
  431. *   TrimSrf: A trimmed surface to free.                                      M
  432. *                                                                            *
  433. * RETURN VALUE:                                                              M
  434. *   void                                                                     M
  435. *                                                                            *
  436. * KEYWORDS:                                                                  M
  437. *   TrimSrfFree, allocation                                                  M
  438. *****************************************************************************/
  439. void TrimSrfFree(TrimSrfStruct *TrimSrf)
  440. {
  441.     TrimCrvFreeList(TrimSrf -> TrimCrvList);
  442.     CagdSrfFree(TrimSrf -> Srf);
  443.     AttrFreeAttributes(&TrimSrf -> Attr);
  444.     IritFree((VoidPtr) TrimSrf);
  445. }
  446.  
  447. /*****************************************************************************
  448. * DESCRIPTION:                                                               M
  449. * Deallocates a list of trimmed surface structures.                         M
  450. *                                                                            *
  451. * PARAMETERS:                                                                M
  452. *   TrimSrfList: A list of trimmed surface to free.                     M
  453. *                                                                            *
  454. * RETURN VALUE:                                                              M
  455. *   void                                                                     M
  456. *                                                                            *
  457. * KEYWORDS:                                                                  M
  458. *   TrimSrfFreeList, allocation                                              M
  459. *****************************************************************************/
  460. void TrimSrfFreeList(TrimSrfStruct *TrimSrfList)
  461. {
  462.     TrimSrfStruct *TrimSrfTemp;
  463.  
  464.     while (TrimSrfList) {
  465.     TrimSrfTemp = TrimSrfList -> Pnext;
  466.     TrimSrfFree(TrimSrfList);
  467.     TrimSrfList = TrimSrfTemp;
  468.     }
  469. }
  470.  
  471. /*****************************************************************************
  472. * DESCRIPTION:                                                               M
  473. * Linearly transforms, in place, given trimmed surface as specified by       M
  474. * Translate and Scale.                                 M
  475. *                                                                            *
  476. * PARAMETERS:                                                                M
  477. *   TrimSrf:       Trimmed surface to transform.                             M
  478. *   Translate:     Translation factor.                                       M
  479. *   Scale:         Scaling factor.                                           M
  480. *                                                                            *
  481. * RETURN VALUE:                                                              M
  482. *   void                                                                     M
  483. *                                                                            *
  484. * KEYWORDS:                                                                  M
  485. *   TrimSrfTransformd                                                     M
  486. *****************************************************************************/
  487. void TrimSrfTransform(TrimSrfStruct *TrimSrf,
  488.               CagdRType *Translate,
  489.               CagdRType Scale)
  490. {
  491.     TrimCrvStruct
  492.     *TrimCrvList = TrimSrf -> TrimCrvList;
  493.  
  494.     /* Transform the geometry. */
  495.     CagdSrfTransform(TrimSrf -> Srf, Translate, Scale);
  496.  
  497.     /* And remove all Euclidean trimming curves. */
  498.     for ( ; TrimCrvList != NULL; TrimCrvList = TrimCrvList -> Pnext) {
  499.     TrimCrvSegStruct
  500.         *TrimCrvSegList = TrimCrvList -> TrimCrvSegList;
  501.  
  502.     for (;
  503.          TrimCrvSegList != NULL;
  504.          TrimCrvSegList = TrimCrvSegList -> Pnext) {
  505.         if (TrimCrvSegList -> EucCrv != NULL) {
  506.         CagdCrvFree(TrimCrvSegList -> EucCrv);
  507.         TrimCrvSegList -> EucCrv = NULL;
  508.         }
  509.     }
  510.     }
  511. }
  512.  
  513. /*****************************************************************************
  514. * DESCRIPTION:                                                               M
  515. * Transforms, in place, the given TV as specified by homogeneous matrix Mat. M
  516. *                                                                            *
  517. * PARAMETERS:                                                                M
  518. *   TV:            Trimariate to transform.                                  M
  519. *   Mat:           Homogeneous transformation to apply to TV.                M
  520. *                                                                            *
  521. * RETURN VALUE:                                                              M
  522. *   void                                                                     M
  523. *                                                                            *
  524. * KEYWORDS:                                                                  M
  525. *   TrimSrfMatTransform, Trimariates                                          M
  526. *****************************************************************************/
  527. void TrimSrfMatTransform(TrimSrfStruct *TrimSrf, CagdMType Mat)
  528. {
  529.     TrimCrvStruct
  530.     *TrimCrvList = TrimSrf -> TrimCrvList;
  531.  
  532.     /* Transform the geometry. */
  533.     CagdSrfMatTransform(TrimSrf -> Srf, Mat);
  534.  
  535.     /* And remove all Euclidean trimming curves. */
  536.     for ( ; TrimCrvList != NULL; TrimCrvList = TrimCrvList -> Pnext) {
  537.     TrimCrvSegStruct
  538.         *TrimCrvSegList = TrimCrvList -> TrimCrvSegList;
  539.  
  540.     for (;
  541.          TrimCrvSegList != NULL;
  542.          TrimCrvSegList = TrimCrvSegList -> Pnext) {
  543.         if (TrimCrvSegList -> EucCrv != NULL) {
  544.         CagdCrvFree(TrimCrvSegList -> EucCrv);
  545.         TrimCrvSegList -> EucCrv = NULL;
  546.         }
  547.     }
  548.     }
  549. }
  550.